Internet Surfer 2.0/Internet Surfer 2.0 (Wayzata Technology) (1996).iso/pc/text/mac/faqs.219

Text File | 1996-02-12 | 25KB | 736 lines

Frequently Asked Questions (FAQS);faqs.219


Article-I.D.: cs.part9_723198982
Expires: Thu, 14 Jan 1993 08:36:22 GMT
References: <[e-mail]>
Sender: [e-mail] (Usenet News System)
Followup-To: sci.cryonics
Organization: School of Computer Science, Carnegie Mellon
Lines: 110
Approved: [e-mail]
Supersedes: <[e-mail]>
Nntp-Posting-Host: u.ergo.cs.cmu.edu

Archive-name: cryonics-faq/part9

             Section 9: Glossary

(You can fetch cryomsg "n" by sending mail to [e-mail] or
to [e-mail] with the subject line "CRYOMSG n".  The index
to this FAQ list is cryomsg "0018.1".)

The next three sections have definitions of cryonics vocabulary.  The
list is divided (at the discretion of the editor) into words to use,
words not to use, and words to use in jest.

                 Words to Use

CRFT has a glossary on pp. 57 - 58.

biostasis - Synonym for "suspension".

cardiac arrest - Cessation of heartbeat.

clinical death - A person is clinically dead if they are in cardiac
arrest and their pupils do not contract when light is shined into them.

cryobiology - Biology at low temperatures.  This includes organ preservation.

cryogenics - Science in general at low temperatures.

cryonics - The practice of freezing people at the end of their natural
lifespan, hoping for eventual reanimation.

information-theoretic death - A person has reached
information-theoretic death if a healthy state of that person could
not possibly be deduced from the current state.  The exact timing of
information-theoretic death depends on presently unknown details of
how the brain works.  The current best estimates put it several hours
after clinical death.

ischemia - Damage to tissues due to oxygen deprivation.

legal death - A person is legally dead if a doctor has signed a death
certificate with his or her name on it.  This tends to happen when the
doctor believes that modern technology will not be able to restore
them to health.  The criteria for legal death change with time.

neurosuspension - The practice of only freezing a person's head or
brain.

revival - The process of restoring a clinically dead person to health.

suspension - The process of preserving a person for eventual revival,
usually by freezing in liquid nitrogen.  This happens after legal
death but hopefully before information-theoretic death.

               Words Not to Use

corpsicle - Pejorative synonym for "suspended person".

cryonicist - An ambiguous term.  1. One who studies or who tries to
improve the process of freezing people for later revival.  Use
"cryonics researcher" instead.  2. One who is interested in cryonics.
Use "cryonics fan" instead, or perhaps "person interested in cryonics".

death - A vague term.  Use "legal death", "clinical death", or
"information-theoretic death" instead.

deanimation - An ugly-sounding synonym for "clinical death".

reanimation - An ugly-sounding synonym for "revival".

             Words To Use In Jest

flexionally disabled - frozen stiff

metabolically disadvantaged - clinically dead

(Next five are from Alcor Indiana Newsletter #5 by Steve Bridge,
cryomsgs 1148 and 1149.)

chronologically gifted - old

experientially enhanced - old

achieved an overall metabolic deficiency - died, possibly frozen

thermally challenged - frozen

assumed room temperature - died, not frozen (Attributed to Rush Limbaugh)

                   Credits

The following people contributed to this document.  Some of them
contributed by posting messages to cryonet or sci.cryonics which I
used.  They are listed in alphabetical order by last name.

  Steve Bridge <[e-mail]>
  Kevin Brown <[e-mail]>
  Tim Freeman <[e-mail]>
  Daniel Green <[e-mail]>
  Steven B. Harris <[e-mail]>
  Bryan Michael Kearney <[e-mail]>
  Simon Levy <[e-mail]>
  Lola McCrary <[e-mail]>
  Perry E. Metzger <[e-mail]>
  Micheal B. O'Neal <[e-mail]>
  Art Quaife <[e-mail]>
  Richard Schroeppel <[e-mail]>
  Ralph Whelan <[e-mail]>
  Brian Wowk <[e-mail]>

and one person on the cryonet mailing list who chose to remain anonymous.
Xref: bloom-picayune.mit.edu comp.lang.c:62383 news.answers:4599
Newsgroups: comp.lang.c,news.answers
Path: bloom-picayune.mit.edu!adam.mit.edu!scs
From: [e-mail] (Steve Summit)
Subject: comp.lang.c Answers (Abridged) to Frequently Asked Questions (FAQ)
Message-ID: <[e-mail]>
Followup-To: poster
Sender: [e-mail] (News system)
Supersedes: <[e-mail]>
Nntp-Posting-Host: adam.mit.edu
Reply-To: [e-mail]
X-Archive-Name: C-faq/abridged
Organization: none, at the moment
Date: Tue, 15 Dec 1992 16:07:35 GMT
X-Last-Modified: November 3, 1992
Approved: [e-mail]
Expires: Wed, 6 Jan 1993 00:00:00 GMT
Lines: 944

Archive-name: C-faq/abridged

[Last modified November 3, 1992 by scs.]

This article contains minimal answers to the comp.lang.c frequently-
asked questions list.  Please see the long version (posted on the
first of each month, or see question 17.21) for more detailed
explanations and references.


Section 1. Null Pointers

1.1:    What is this infamous null pointer, anyway?

A:    For each pointer type, there is a special value -- the "null
    pointer" -- which is distinguishable from all other pointer
    values and which is not the address of any object.

1.2:    How do I "get" a null pointer in my programs?

A:    A constant 0 in a pointer context is converted into a null
    pointer at compile time.  A "pointer context" is an
    initialization, assignment, or comparison with one side a
    variable or expression of pointer type, and (in ANSI standard C)
    a function argument which has a prototype in scope declaring a
    certain parameter as being of pointer type.  In other contexts
    (function arguments without prototypes, or in the variable part
    of variadic function calls) a constant 0 with an appropriate
    explicit cast is required.

1.3:    What is NULL and how is it #defined?

A:    NULL is simply a preprocessor macro, #defined as 0 (or
    (void *)0), which is used (as a stylistic convention, in
    preference to unadorned 0's) to generate null pointers,

1.4:    How should NULL be #defined on a machine which uses a nonzero
    bit pattern as the internal representation of a null pointer?

A:    The same as any other machine: as 0 (or (void *)0).  (The
    compiler makes the translation, upon seeing a 0, not the
    preprocessor.)

1.5:    If NULL were defined as "(char *)0," wouldn't that make function
    calls which pass an uncast NULL work?

A:    Not in general.  The problem is that there are machines which
    use different internal representations for pointers to different
    types of data.  A cast is still required to tell the compiler
    which kind of null pointer is required, since it may be
    different from (char *)0.

1.6:    I use the preprocessor macro "#define Nullptr(type) (type *)0"
    to help me build null pointers of the correct type.

A:    This trick, though valid, does not buy much.

1.7:    Is the abbreviated pointer comparison "if(p)" to test for non-
    null pointers valid?  What if the internal representation for
    null pointers is nonzero?

A:    The construction "if(p)" works, regardless of the internal
    representation of null pointers, because the compiler
    essentially rewrites it as "if(p != 0)" and goes on to convert 0
    into the correct null pointer.

1.8:    If "NULL" and "0" are equivalent, which should I use?

A:    Either; the distinction is entirely stylistic.

1.9:    But wouldn't it be better to use NULL (rather than 0) in case
    the value of NULL changes, perhaps on a machine with nonzero
    null pointers?

A:    No.  NULL is, and will always be, 0.

1.10:    I'm confused.  NULL is guaranteed to be 0, but the null pointer
    is not?

A:    A "null pointer" is a language concept whose particular internal
    value does not matter.  A null pointer is requested in source
    code with the character "0".  "NULL" is a preprocessor macro,
    which is always #defined as 0 (or (void *)0).

1.11:    Why is there so much confusion surrounding null pointers?  Why
    do these questions come up so often?

A:    The fact that null pointers are represented both in source code,
    and internally to most machines, as zero invites unwarranted
    assumptions.  The use of a preprocessor macro (NULL) suggests
    that the value might change later, or on some weird machine.

1.12:    I'm still confused.  I just can't understand all this null
    pointer stuff.

A:    A simple rule is, "Always use `0' or `NULL' for null pointers,
    and always cast them when they are used as arguments in function
    calls."

1.13:    Given all the confusion surrounding null pointers, wouldn't it
    be easier simply to require them to be represented internally by
    zeroes?

A:    Such a requirement would accomplish little.

1.14:    Seriously, have any actual machines really used nonzero null
    pointers?

A:    Machines manufactured by Prime and by Honeywell-Bull, as well as
    Symbolics Lisp Machines, have done so.


Section 2. Arrays and Pointers

2.1:    I had the definition char a[6] in one source file, and in
    another I declared extern char *a.  Why didn't it work?

A:    The declaration extern char *a simply does not match the actual
    definition.  Use extern char a[].

2.2:    But I heard that char a[] was identical to char *a.

A:    Not at all.  Arrays are not pointers.  A reference like x[3]
    generates different code depending on whether x is an array or a
    pointer.

2.3:    So what is meant by the "equivalence of pointers and arrays"
    in C?

A:    An lvalue of type array-of-T which appears in an expression
    decays into a pointer to its first element; the type of the
    resultant pointer is pointer-to-T.  So for an array a and
    pointer p, you can say "p = a;" and then p[3] and a[3] will
    access the same element.

2.4:    Why are array and pointer declarations interchangeable as
    function formal parameters?

A:    Since functions can never receive arrays as parameters, any
    parameter declarations which "look like" arrays are treated by
    the compiler as if they were pointers.

2.5:    Why doesn't sizeof properly report the size of an array which is
    a parameter to a function?

A:    The sizeof operator reports the size of the pointer parameter
    which the function actually receives.

2.6:    Someone explained to me that arrays were really just constant
    pointers.

A:    An array name is "constant" in that it cannot be assigned to,
    but an array is _not_ a pointer.

2.7:    I came across some "joke" code containing the "expression"
    5["abcdef"] .  How can this be legal C?

A:    Yes, array subscripting is commutative in C.  The array
    subscripting operation a[e] is defined as being equivalent to
    *((a)+(e)).

2.8:    My compiler complained when I passed a two-dimensional array to
    a routine expecting a pointer to a pointer.

A:    The rule by which arrays decay into pointers is not applied
    recursively.  An array of arrays (i.e. a two-dimensional array
    in C) decays into a pointer to an array, not a pointer to a
    pointer.

2.9:    How do I declare a pointer to an array?

A:    Usually, you don't want to.  Consider using a pointer to one of
    the array's elements instead.

2.10:    How can I dynamically allocate a multidimensional array?

A:    It is usually best to allocate an array of pointers, and then
    initialize each pointer to a dynamically-allocated "row."
    See the full list for code samples.

2.11:    Can I simulate a non-0-based array with a pointer?

A:    Not if the pointer points outside of the block of memory it is
    intended to access.

2.12:    I passed a pointer to a function which initialized it, but the
    pointer in the caller was unchanged.

A:    The called function probably altered only the passed copy of the
    pointer.

2.13:    I have a char * pointer that happens to point to some ints, and
    I want to step it over them.  Why doesn't "((int *)p)++;" work?

A:    In C, a cast operator is a conversion operator, and by
    definition it yields an rvalue, which cannot be assigned to, or
    incremented with ++.


Section 3. Memory Allocation

3.1:    Why doesn't the code "char *answer; gets(answer);" work?

A:    The pointer variable "answer" has not been set to point to any
    valid storage.  The simplest way to correct this fragment is to
    use a local array, instead of a pointer.

3.2:    I can't get strcat to work.  I tried "char *s1 = "Hello, ",
    *s2 = "world!", *s3 = strcat(s1, s2);" but I got strange
    results.

A:    Again, the problem is that space for the concatenated result is
    not properly allocated.

3.3:    But the man page for strcat says that it takes two char *'s as
    arguments.  How am I supposed to know to allocate things?

A:    In general, when using pointers you _always_ have to consider
    memory allocation, at least to make sure that the compiler is
    doing it for you.

3.4:    I have a function that is supposed to return a string, but when
    it returns to its caller, the returned string is garbage.

A:    Make sure that the memory to which the function returns a
    pointer is correctly (i.e. not locally) allocated.

3.5:    You can't use dynamically-allocated memory after you free it,
    can you?

A:    No.  Some early man pages implied otherwise, but the claim is no
    longer valid.

3.6:    How does free() know how many bytes to free?

A:    The malloc/free package remembers the size of each block it
    allocates and returns.

3.7:    So can I query the malloc package to find out how big an
    allocated block is?

A:    Not portably.

3.8:    Is it legal to pass a null pointer as the first argument to
    realloc()?

A:    ANSI C sanctions this usage, but several earlier implementations
    do not support it.

3.9:    Is it safe to use calloc's zero-fill guarantee for pointer and
    floating-point values?

A:    No.

3.10:    What is alloca and why is its use discouraged?

A:    alloca allocates memory which is automatically freed when the
    function which called alloca returns.  alloca cannot be written
    portably, is difficult to implement on machines without a stack,
    and fails under certain conditions if implemented simply.


Section 4. Expressions

4.1:    Why doesn't the code "a[i] = i++;" work?

A:    The variable i is both referenced and modified in the same
    expression.

4.2:    Under my compiler, the code "int i = 7; printf("%d\n", i++ * i++);"
    prints 49.  Regardless of the order of evaluation, shouldn't it
    print 56?

A:    The operations implied by the postincrement and postdecrement
    operators ++ and -- are performed at some time after the
    operand's former values are yielded and before the end of the
    expression, but not necessarily immediately after, or before
    other parts of the expression are evaluated.

4.3:    But what about the &&, ||, and comma operators?

A:    There is a special exception for those operators, (as well
    as ?: ); left-to-right evaluation is guaranteed.

4.4:    If I'm not using the value of the expression, should I use i++
    or ++i to increment a variable?

A:    Since the two forms differ only in the value yielded, they are
    entirely equivalent when only their side effect is needed.

4.5:    Why doesn't the code "int a = 1000, b = 1000;
    long int c = a * b;" work?

A:    You must manually cast one of the operands to (long).


Section 5. ANSI C

5.1:    What is the "ANSI C Standard?"

A:    In 1983, the American National Standards Institute commissioned
    a committee, X3J11, to standardize the C language.  After a
    long, arduous process, the committee's work was finally ratified
    as an American National Standard, X3.159-1989, on December 14,
    1989, and published in the spring of 1990.  The Standard has
    also been adopted as ISO/IEC 9899:1990.

5.2:    How can I get a copy of the Standard?

A:    Copies are available from the American National Standards
    Institute in New York, or from Global Engineering Documents in
    Irvine, CA.  See the unabridged list for addresses.

5.3:    Does anyone have a tool for converting old-style C programs to
    ANSI C, or for automatically generating prototypes?

A:    See the full list for details.

5.4:    How do I keep the ANSI "stringizing" preprocessing operator from
    stringizing the macro's name rather than its value?

A:    You must use a two-step #definition to force the macro to be
    expanded as well as stringized.

5.5:    What's the difference between "char const *p" and
    "char * const p"?

A:    The former is a pointer to a constant character; the latter is a
    constant pointer to a character.

5.6:    My ANSI compiler complains about a mismatch when it sees

        extern int func(float);

        int func(x)
        float x;
        {...

A:    You have mixed the new-style prototype declaration
    "extern int func(float);" with the old-style definition
    "int func(x) float x;".  "Narrow" types are treated differently
    according to which syntax is used.  The problem can be fixed by
    using either new-style (prototype) or old-style syntax
    consistently.

5.7:    I'm getting strange syntax errors inside code which I've
    #ifdeffed out.

A:    Under ANSI C, #ifdeffed-out text must still consist of "valid
    preprocessing tokens."  This means that there must be no
    unterminated comments or quotes (i.e. no single apostrophes),
    and no newlines inside quotes.

5.8:    Can I declare main as void, to shut off these annoying "main
    returns no value" messages?

A:    No.

5.9:    Why does the ANSI Standard not guarantee more than six monocase
    characters of external identifier significance?

A:    The problem is older linkers which cannot be forced (by mere
    words in a Standard) to upgrade.

5.10:    What is the difference between memcpy and memmove?

A:    memmove offers guaranteed behavior if the source and destination
    arguments overlap.

5.11:    My compiler is rejecting the simplest possible test programs,
    with all kinds of syntax errors.

A:    Perhaps it is a pre-ANSI compiler.

5.12:    Why won't frobozz-cc, which claims to be ANSI compliant, accept
    this code?

A:    Are you sure that the code being rejected doesn't rely on some
    non-Standard extension?

5.13:    What are #pragmas and what are they good for?

A:    The #pragma directive provides a single, well-defined "escape
    hatch" which can be used for extensions.


Section 6. C Preprocessor

6.1:    How can I write a generic macro to swap two values?

A:    There is no good answer to this question.  The best all-around
    solution is probably to forget about using a macro.

6.2:    I have some old code that tries to construct identifiers with a
    macro like "#define Paste(a, b) a/**/b ", but it doesn't work
    any more.

A:    Try the ANSI token-pasting operator ##.

6.3:    What's the best way to write a multi-statement cpp macro?

A:    #define Func() do {stmt1; stmt2; ... } while(0)  /* (no trailing ;) */

6.4:    Is it acceptable for one header file to #include another?

A:    There has been considerable debate surrounding this question.

6.5:    Does the sizeof operator work in preprocessor #if directives?

A:    No.

6.6:    How can I use a preprocessor #if expression to detect
    endianness?

A:    You probably can't.

6.7:    I've got this tricky processing I want to do at compile time and
    I can't figure out a way to get cpp to do it.

A:    Consider writing your own little special-purpose preprocessing
    tool, instead.

6.8:    How can I write a cpp macro which takes a variable number of
    arguments?

A:    Here is one popular trick.  Note that the parentheses around
    printf's argument list are in the macro call, not the
    definition.

        #define DEBUG(args) (printf("DEBUG: "), printf args)

        if(n != 0) DEBUG(("n is %d\n", n));


Section 7. Variable-Length Argument Lists

7.1:    How can I write a function that takes a variable number of
    arguments?

A:    Use the <stdarg.h> (or older <varargs.h>) header.

7.2:    How can I write a function that takes a format string and a
    variable number of arguments, like printf, and passes them to
    printf to do most of the work?

A:    Use vprintf, vfprintf, or vsprintf.

7.3:    How can I discover how many arguments a function was actually
    called with?

A:    Any function which takes a variable number of arguments must be
    able to determine from the arguments themselves how many of them
    there are.

7.4:    How can I write a function which takes a variable number of
    arguments and passes them to some other function (which takes a
    variable number of arguments)?

A:    In general, you cannot.

7.5:    How can I call a function with an argument list built up at run
    time?

A:    You can't.


Section 8. Boolean Expressions and Variables

8.1:    What is the right type to use for boolean values in C?  Why
    isn't it a standard type?  Should #defines or enums be used for
    the true and false values?

A:    C does not provide a standard boolean type, because picking one
    involves a space/time tradeoff which is best decided by the
    programmer.  The choice between #defines and enums is arbitrary
    and not terribly interesting.

8.2:    Isn't #defining TRUE to be 1 dangerous, since any nonzero value
    is considered "true" in C?  What if a built-in boolean or
    relational operator "returns" something other than 1?

A:    It is true (sic) that any nonzero value is considered true in C,
    but this applies only "on input", i.e. where a boolean value is
    expected.  When a boolean value is generated by a built-in
    operator, it is guaranteed to be 1 or 0.  (This is _not_ true
    for some library routines such as isalpha.)


Section 9. Structs, Enums, and Unions

9.1:    What is the difference between an enum and a series of
    preprocessor #defines?

A:    At the present time, there is little difference.  The ANSI
    standard states that enumerations are compatible with integral
    types.

9.2:    I heard that structures could be assigned to variables and
    passed to and from functions, but K&R I says not.

A:    These operations are supported by all modern compilers.

9.3:    How does struct passing and returning work?

A:    If you really need to know, see the unabridged list.

9.4:    I have a program which works correctly, but dumps core after it
    finishes.  Why?

A:    Check to see if a structure type declaration just before main is
    missing its trailing semicolon, causing the compiler to believe
    that main returns a structure.  See also question 17.15.

9.5:    Why can't you compare structs?

A:    There is no reasonable way for a compiler to implement struct
    comparison which is consistent with C's low-level flavor.

9.6:    I came across some code that declared a structure with the last
    member an array of one element, and then did some tricky
    allocation to make the array act like it had several elements.
    Is this legal and/or portable?

A:    The ANSI C standard allows it, but only implicitly.

9.7:    How can I determine the byte offset of a field within a
    structure?

A:    ANSI C defines the offsetof macro, which should be used if
    available.

9.8:    How can I access structure fields by name at run time?

A:    Build a table of names and offsets, using the offsetof() macro.

9.9:    Why does sizeof report a larger size than I expect for a
    structure type, as if there was padding at the end?

A:    The alignment of arrays of structures must be preserved.

9.10:    How can I turn off structure padding?

A:    There is no standard method.

9.11:    Can I initialize unions?

A:    ANSI Standard C allows an initializer for the first member.


Section 10. Declarations

10.1:    How do you decide which integer type to use?

A:    If you might need large values, use long.  Otherwise, if space
    is very important, use short.  Otherwise, use int.

10.2:    I can't seem to define a linked list node which contains a
    pointer to itself.

A:    Structs in C can certainly contain pointers to themselves; the
    discussion and example in section 6.5 of K&R make this clear.
    Problems arise if an attempt is made to define (and use) a
    typedef in the midst of such a declaration; avoid this.

10.3:    How do I declare an array of pointers to functions returning
    pointers to functions returning pointers to characters?

A:    char *(*(*a[5])())();
    Using a chain of typedefs, or the cdecl program, makes these
    declarations easier.

10.4:    How can I declare a function that returns a pointer to a
    function of its own type?

A:    You can't do it directly.

10.5:    What's the best way to declare and define global variables?

A:    It is best to place the definition in some central .c file, with
    an external declaration in a header file.

10.6:    How do I initialize a pointer to a function?

A:    Use something like "extern int func(); int (*fp)() = func;" .

10.7:    I've seen different methods used for calling through pointers to
    functions.

A:    The extra parentheses and explicit * are now officially
    optional, although some older implementations require them.